/**
 * CompoundPath
 *
 */
if(typeof (module) !="undefined"){
    module.exports = CompoundPath;

    var Point = require('./Point');
    var PointPath = require('./PointPath');
    var FMatrix = require('./FMatrix');
    var define = require('../../define').getDefine();
}





function CompoundPath(){
    // 包含多个简单路径
    this.paths= new Array();
    this.w=0;
    this.h=0;
    // 类型为文字时，每个字的x和y相对于文字的左上角，子路径的所有点相对于该x和y
    // 类型为图形时，此x和y可以忽略不计，子路径的所有点相对于图形的左上角。
    this.x=0;
    this.y=0;
    // 子的baseline的坐标
    this.bx=0;
    this.by=0;


    this.m=null; // 变换矩阵，在文字时有效；其它情况无效（相对于原始轮廓（从服务器返回的轮廓）的绝对缩放矩阵）
}
// 转成json字符串
// 参数： frame为true，表示转成frame（所谓frame指的是文字的每个字的x、y、w、h，matrix但不包括文字的每个点）
CompoundPath.prototype.toJson = function (frame){
    frame = (frame)? true:false;

    var ret = '{';

    // 如果frame为true，不需要存储paths
    if(!frame){
        ret +='"paths":[';
        for(var i=0;i<this.paths.length;i++){
            if(i>0){
                ret +=',';
            }
            ret += this.paths[i].toJson();
        }
        ret +=']';
        ret +=',';
    }

    ret +=('"w":'+this.w);
    ret +=',';
    ret +=('"h":'+this.h);
    ret +=',';
    ret +=('"x":'+this.x);
    ret +=',';
    ret +=('"y":'+this.y);
    ret +=',';
    ret +=('"bx":'+this.bx);
    ret +=',';
    ret +=('"by":'+this.by);

    // matrix
    if(this.m){
        ret +=',';
        ret +=('"m":'+this.m.toJson());
    }

    ret +='}';
    return ret;
}
// 从json对象中解析
// 参数： frame为true，表示从frame中解析（所谓frame指的是文字的每个字的x、y、w、h，但不包括文字的每个点）
CompoundPath.prototype.fromJson = function(jsonObj, versionId,frame){
    frame = (typeof frame ==undefined || typeof frame ==undefined)? false:frame;

    this.w = jsonObj.w*1;
    this.h = jsonObj.h*1;
    if(jsonObj.hasOwnProperty("x"))
        this.x = jsonObj.x;
    if(jsonObj.hasOwnProperty("y"))
        this.y = jsonObj.y;
    if(jsonObj.hasOwnProperty("bx"))
        this.bx = jsonObj.bx;
    if(jsonObj.hasOwnProperty("by"))
        this.by = jsonObj.by;

    // 如果frame为true，不需要解析paths
    if(!frame){
        this.paths.splice(0,this.paths.length);
        if(jsonObj.hasOwnProperty('paths')){
            for(var i=0;i<jsonObj.paths.length;i++){
                var path= new PointPath();
                path.fromJson(jsonObj.paths[i],versionId);
                this.paths.push(path);
            }
        }
    }

    // matrix
    if(jsonObj.hasOwnProperty('m')){
        this.m = new FMatrix();
        this.m.fromJson(jsonObj.m);
    }
}

/**
 * 利用ParaControu的矩阵和CompoundPath的矩阵更新轮廓点
 * 参数：
 *      pcMatrix：ParaContour的矩阵，可能为null
 */
CompoundPath.prototype.multiplyMatrix= function(pcMatrix){

}
/**
 * 转换成SVG格式的字符串：
 *      'M 0,20 L 100,160 Q 130,200 150,120 C 190,-40 200,200 300,150 L 400,90 z
 *       M 0,20 L 100,160 Q 130,200 150,120 C 190,-40 200,200 300,150 L 400,90 z'
 */
CompoundPath.prototype.toSvgPath= function(){
    var ret = "";
    for(var i=0;i<this.paths.length;i++){
        if(i>0)
            ret +=" ";
        ret += this.paths[i].toSvgPath(this.x, this.y);
    }
    return ret;
}

// 调整复合路径，平移或者缩放
// 参数
//		charContour:复合路径
//		vW:水平方向的平移值或者缩放值
//		vH:垂直方向的平移值或者缩放值
// 		type:类型，1 平移  2 缩放
CompoundPath.prototype.adjustPosition= function(vW,vH, type) {

    if(2==type){
        this.w *= vW;
        this.h *= vH;
        this.x *= vW;
        this.y *= vH;
        this.bx *= vW;
        this.by *= vH;
        for(var k = 0; k < this.paths.length; k++) {

            var pointPath = this.paths[k] ;
            pointPath.adjustPosition(vW,vH,type);
        }
    }else{
        // 复合路径只需要平移自身的 xy即可（其子的坐标系为复合路径的左上角）
        this.x += vW;
        this.y += vH;
    }

}

